/***************************************************/
/***********  0.  常量定义 2016.07.23    ***********/
/***************************************************/
//Crypto COM常量
var NETCAPKI_ALGORITHM_3DES_CBC = 16777216;
var NETCAPKI_ALGORITHM_3DES_ECB = 12582912;
var NETCAPKI_ALGORITHM_AES_CBC = 41943040;
var NETCAPKI_ALGORITHM_AES_ECB = 37748736;
var NETCAPKI_ALGORITHM_DES_CBC = 8388608;
var NETCAPKI_ALGORITHM_DES_ECB = 4194304;
var NETCAPKI_ALGORITHM_DH = 3;
var NETCAPKI_ALGORITHM_DSA = 2;
var NETCAPKI_ALGORITHM_ECC = 4;
var NETCAPKI_ALGORITHM_HMAC_MD5 = 131072;
var NETCAPKI_ALGORITHM_HMAC_SHA1 = 262144;
var NETCAPKI_ALGORITHM_HMAC_SHA224 = 393216;
var NETCAPKI_ALGORITHM_HMAC_SHA256 = 524288;
var NETCAPKI_ALGORITHM_HMAC_SHA384 = 655360;
var NETCAPKI_ALGORITHM_HMAC_SHA512 = 786432;
var NETCAPKI_ALGORITHM_HMAC_SM3 = 1048576;
var NETCAPKI_ALGORITHM_MD5 = 4096;
var NETCAPKI_ALGORITHM_MD5WITHRSA = 1;
var NETCAPKI_ALGORITHM_RC4 = 25165824;
var NETCAPKI_ALGORITHM_RSA = 1;
var NETCAPKI_ALGORITHM_RSA_PKCS1_V1_5_ENC = 16;
var NETCAPKI_ALGORITHM_RSA_RAW_ENC = 48;
var NETCAPKI_ALGORITHM_SHA1 = 8192;
var NETCAPKI_ALGORITHM_SHA1WITHRSA = 2;
var NETCAPKI_ALGORITHM_SHA224 = 12288;
var NETCAPKI_ALGORITHM_SHA224WITHRSA = 3;
var NETCAPKI_ALGORITHM_SHA256 = 16384;
var NETCAPKI_ALGORITHM_SHA256WITHRSA = 4;
var NETCAPKI_ALGORITHM_SHA384 = 20480;
var NETCAPKI_ALGORITHM_SHA384WITHRSA = 5;
var NETCAPKI_ALGORITHM_SHA512 = 24576;
var NETCAPKI_ALGORITHM_SHA512WITHRSA = 6;
var NETCAPKI_ALGORITHM_SM1_CBC = 67108864;
var NETCAPKI_ALGORITHM_SM1_ECB = 62914560;
var NETCAPKI_ALGORITHM_SM2_ENC = 64;
var NETCAPKI_ALGORITHM_SM3 = 28672;
var NETCAPKI_ALGORITHM_SM3WITHRSA = 31;
var NETCAPKI_ALGORITHM_SM3WITHSM2 = 25;
var NETCAPKI_ALGORITHM_SM4_CBC = 79691776;
var NETCAPKI_ALGORITHM_SM4_ECB = 75497472;
var NETCAPKI_ALGORITHM_SMS4_CBC = 79691776;
var NETCAPKI_ALGORITHM_SMS4_ECB = 75497472;
var NETCAPKI_ALGORITHM_SSF33_CBC = 54525952;
var NETCAPKI_ALGORITHM_SSF33_ECB = 50331648;
var NETCAPKI_BASE64_DECODE_STRICT = 2;
var NETCAPKI_BASE64_ENCODE_NO_NL = 1;
var NETCAPKI_BMPSTRING = 5;
var NETCAPKI_CERT_ATTRIBUTE_CERT_POLICY_OID = 61;
var NETCAPKI_CERT_ATTRIBUTE_CHECK_PRIVKEY = 54;
var NETCAPKI_CERT_ATTRIBUTE_CRL_URL = 56;
var NETCAPKI_CERT_ATTRIBUTE_CSP_NAME = 55;
var NETCAPKI_CERT_ATTRIBUTE_DELTA_CRL_URL = 57;
var NETCAPKI_CERT_ATTRIBUTE_DNS_NAME = 60;
var NETCAPKI_CERT_ATTRIBUTE_EX_DEPARTMENT = 25;
var NETCAPKI_CERT_ATTRIBUTE_EX_DEVICE_SN = 42;
var NETCAPKI_CERT_ATTRIBUTE_EX_DEVICE_TYPE = 41;
var NETCAPKI_CERT_ATTRIBUTE_EX_EMAIL = 26;
var NETCAPKI_CERT_ATTRIBUTE_EX_FRIENDLY_NAME = 22;
var NETCAPKI_CERT_ATTRIBUTE_EX_NAME = 23;
var NETCAPKI_CERT_ATTRIBUTE_EX_ORGANIZATION = 24;
var NETCAPKI_CERT_ATTRIBUTE_EXTENDED_KEY_USAGE = 62;
var NETCAPKI_CERT_ATTRIBUTE_IP = 59;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_C = 10;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_CN = 13;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_DISPLAY_NAME = 9;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_EMAIL = 14;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_HEX_ENCODE = 53;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_L = 38;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_LDAP_NAME = 48;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_O = 11;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_OU = 12;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_ST = 37;
var NETCAPKI_CERT_ATTRIBUTE_ISSUER_XMLSIG_NAME = 49;
var NETCAPKI_CERT_ATTRIBUTE_OCSP_URL = 58;
var NETCAPKI_CERT_ATTRIBUTE_PREVCERT_THUMBPRINT = 29;
var NETCAPKI_CERT_ATTRIBUTE_PUBKEY_ECC_CURVE = 43;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_C = 17;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_CN = 20;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_DISPLAY_NAME = 16;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_EMAIL = 21;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_HEX_ENCODE = 52;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_L = 40;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_LDAP_NAME = 50;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_O = 18;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_OU = 19;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_ST = 39;
var NETCAPKI_CERT_ATTRIBUTE_SUBJECT_XMLSIG_NAME = 51;
var NETCAPKI_CERT_ATTRIBUTE_UPN = 36;
var NETCAPKI_CERT_ENCODE_BASE64 = 2;
var NETCAPKI_CERT_ENCODE_BASE64_NO_NL = 3;
var NETCAPKI_CERT_ENCODE_DER = 1;
var NETCAPKI_CERT_PURPOSE_ENCRYPT = 1;
var NETCAPKI_CERT_PURPOSE_SIGN = 2;
var NETCAPKI_CERT_PURPOSE_VERIFY_OLD_DATA = 268435458;
var NETCAPKI_CERT_STATUS_CA_REVOKED = -2;
var NETCAPKI_CERT_STATUS_REVOKED = 0;
var NETCAPKI_CERT_STATUS_UNDETERMINED = -1;
var NETCAPKI_CERT_STATUS_UNREVOKED = 1;
var NETCAPKI_CERT_STORE_NAME_CA = "ca";
var NETCAPKI_CERT_STORE_NAME_MY = "my";
var NETCAPKI_CERT_STORE_NAME_OTHERS = "others";
var NETCAPKI_CERT_STORE_NAME_ROOT = "root";
var NETCAPKI_CERT_STORE_TYPE_CURRENT_USER = 0;
var NETCAPKI_CERT_STORE_TYPE_LOCAL_MACHINE = 1;
var NETCAPKI_CERT_STORE_TYPE_MEMORY = 2;
var NETCAPKI_CERT_TYPE_LOCAL_MACHINE = 32768;
var NETCAPKI_CERT_VERIFY_FLAG_ONLINE = 2;
var NETCAPKI_CERT_VERIFY_FLAG_VERIFY_CACERT_REVOKE = 4;
var NETCAPKI_CERT_VERIFY_FLAG_VERIFY_CRL = 32;
var NETCAPKI_CERT_VERIFY_FLAG_VERIFY_OCSP = 16;
var NETCAPKI_CERT_VERIFY_FLAG_VERIFY_REVOKE = 1;
var NETCAPKI_CERTVERIFY_OPTION_IGNOREALLEXT = 4;
var NETCAPKI_CERTVERIFY_OPTION_ONLINE_GETCACERT = 32;
var NETCAPKI_CERTVERIFY_OPTION_ONLINE_GETREVOKEINFO = 64;
var NETCAPKI_CERTVERIFY_OPTION_USEALLCACERT = 2;
var NETCAPKI_CERTVERIFY_OPTION_USEV1CERT = 1;
var NETCAPKI_CERTVERIFY_OPTION_VERIFYCAREVOKE = 16;
var NETCAPKI_CERTVERIFY_OPTION_VERIFYEEREVOKE = 8;
var NETCAPKI_CMS_ENCODE_BASE64 = 2;
var NETCAPKI_CMS_ENCODE_BASE64_MULTILINE = 3;
var NETCAPKI_CMS_ENCODE_DER = 1;
var NETCAPKI_CP_ACP = 0;
var NETCAPKI_CP_BIG5 = 950;
var NETCAPKI_CP_GB18030 = 54936;
var NETCAPKI_CP_GBK = 936;
var NETCAPKI_CP_UTF16LE = 1200;
var NETCAPKI_CP_UTF8 = 65001;
var NETCAPKI_CRL_REASON_AACOMPROMISE = 10;
var NETCAPKI_CRL_REASON_AFFILIATION_CHANGED = 3;
var NETCAPKI_CRL_REASON_CACOMPROMISE = 2;
var NETCAPKI_CRL_REASON_CERTIFATE_HOLD = 6;
var NETCAPKI_CRL_REASON_CESSATION_OF_OPERATION = 5;
var NETCAPKI_CRL_REASON_KEYCOMPROMISE = 1;
var NETCAPKI_CRL_REASON_PRIVILEGE_WITHDRAWN = 9;
var NETCAPKI_CRL_REASON_REMOVE_FROM_CRL = 8;
var NETCAPKI_CRL_REASON_SUPERSEDED = 4;
var NETCAPKI_CRL_REASON_UNSPECIFIED = 0;
var NETCAPKI_DEVICEFLAG_CACHE_PIN_IN_HANDLE = 2;
var NETCAPKI_DEVICEFLAG_CACHE_PIN_IN_PROCESS = 0;
var NETCAPKI_DEVICEFLAG_NOT_CACHE_PIN = 4;
var NETCAPKI_DEVICEFLAG_SILENT = 1;
var NETCAPKI_DEVICETYPE_ANY = -1;
var NETCAPKI_DEVICETYPE_EKEY_EKPK = 1;
var NETCAPKI_DEVICETYPE_EKEY_EKPKXC_V2 = 2;
var NETCAPKI_DEVICETYPE_EKEY_EKPKXC_V3 = 6;
var NETCAPKI_DEVICETYPE_EPASS3000 = 3;
var NETCAPKI_DEVICETYPE_EPASS3003 = 5;
var NETCAPKI_DEVICETYPE_ETAX = 30;
var NETCAPKI_DEVICETYPE_HAIKEY = 4;
var NETCAPKI_DEVICETYPE_HAIKEY_SM2 = 33;
var NETCAPKI_DEVICETYPE_HWETAX = 31;
var NETCAPKI_DEVICETYPE_SJY03B = 101;
var NETCAPKI_DEVICETYPE_SJY05B = 100;
var NETCAPKI_DEVICETYPE_SOFTWARE = 0;
var NETCAPKI_ECC_CURVE_P192 = 1;
var NETCAPKI_ECC_CURVE_P224 = 2;
var NETCAPKI_ECC_CURVE_P256 = 3;
var NETCAPKI_ECC_CURVE_P384 = 4;
var NETCAPKI_ECC_CURVE_P521 = 5;
var NETCAPKI_ECC_CURVE_SM2 = 7;
var NETCAPKI_ECC_CURVE_WAPI = 6;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_AES128CBC = 4;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_AES192CBC = 5;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_AES256CBC = 6;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_SM1CBC = 8;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_SM4CBC = 9;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_SMS4CBC = 9;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_SSF33CBC = 7;
var NETCAPKI_ENVELOPEDDATA_ALGORITHM_TDESCBC = 3;
var NETCAPKI_IA5STRING = 3;
var NETCAPKI_KEYPAIR_ENCRYPT = 1;
var NETCAPKI_KEYPAIR_SIGNATURE = 2;
var NETCAPKI_KEYUSAGE_CONTENTCOMMITMENT = 2;
var NETCAPKI_KEYUSAGE_CRLSIGN = 64;
var NETCAPKI_KEYUSAGE_DATAENCIPHERMENT = 8;
var NETCAPKI_KEYUSAGE_DECIPHERONLY = 256;
var NETCAPKI_KEYUSAGE_DIGITALSIGNATURE = 1;
var NETCAPKI_KEYUSAGE_ENCIPHERONLY = 128;
var NETCAPKI_KEYUSAGE_KEYAGRESSMENT = 16;
var NETCAPKI_KEYUSAGE_KEYCERTSIGN = 32;
var NETCAPKI_KEYUSAGE_KEYENCIPHERMENT = 4;
var NETCAPKI_KEYUSAGE_NONREPUDIATION = 2;
var NETCAPKI_MAJOR_VERSION = 1;
var NETCAPKI_MIME_TYPE_BASIC = 0;
var NETCAPKI_MIME_TYPE_MESSAGE = 2;
var NETCAPKI_MIME_TYPE_MULTIPART = 1;
var NETCAPKI_MINOR_VERSION = 0;
var NETCAPKI_OID = 6;
var NETCAPKI_PADDING_NONE = 1;
var NETCAPKI_PADDING_PKCS5 = 2;
var NETCAPKI_PRINTABLESTRING = 2;
var NETCAPKI_REGCERT_IN_MS_CERTSTORE = 2;
var NETCAPKI_REGCERT_IN_NETCA_CERTSTORE = 1;
var NETCAPKI_SEARCH_KEYPAIR_FLAG_CURRENT_USER = 1073741824;
var NETCAPKI_SEARCH_KEYPAIR_FLAG_DEVICE = 268435456;
var NETCAPKI_SEARCH_KEYPAIR_FLAG_LOCAL_MACHINE = 536870912;
var NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION_CERTPATH = 3;
var NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION_CERTPATHWITHROOT = 4;
var NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION_NONE = 1;
var NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION_SELF = 2;
var NETCAPKI_SIGNEDDATA_VERIFY_LEVEL_NO_VERIFY = 0;
var NETCAPKI_SIGNEDDATA_VERIFY_LEVEL_VERIFY_CERT = 2;
var NETCAPKI_SIGNEDDATA_VERIFY_LEVEL_VERIFY_CERT_REVOKE = 3;
var NETCAPKI_SIGNEDDATA_VERIFY_LEVEL_VERIFY_CERTPATH_REVOKE = 4;
var NETCAPKI_SIGNEDDATA_VERIFY_LEVEL_VERIFY_SIGNATURE_ONLY = 1;
var NETCAPKI_SO_PWD = 2;
var NETCAPKI_TIMESTAMP_RESP_STATUS_BADRESP = -1;
var NETCAPKI_TIMESTAMP_RESP_STATUS_BADTSACERT = -2;
var NETCAPKI_TIMESTAMP_RESP_STATUS_GRANTED = 0;
var NETCAPKI_TIMESTAMP_RESP_STATUS_GRANTEDWITHMODS = 1;
var NETCAPKI_TIMESTAMP_RESP_STATUS_REJECTION = 2;
var NETCAPKI_TIMESTAMP_RESP_STATUS_REVOCATIONNOTIFICATION = 5;
var NETCAPKI_TIMESTAMP_RESP_STATUS_REVOCATIONWARNING = 4;
var NETCAPKI_TIMESTAMP_RESP_STATUS_WAITING = 3;
var NETCAPKI_UIFLAG_ALWAYS_UI = 3;
var NETCAPKI_UIFLAG_DEFAULT_UI = 1;
var NETCAPKI_UIFLAG_NO_UI = 2;
var NETCAPKI_USER_PWD = 1;
var NETCAPKI_UTF8STRING = 1;
var NETCAPKI_VISIBLESTRING = 4;

//定制6：RSA签名算法，一般无需定制
var NETCAPKI_ALGORITHM_RSASIGN = NETCAPKI_ALGORITHM_SHA1WITHRSA;

//定制11：签名包含证书的选项，一般无需定制
var NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION =NETCAPKI_SIGNEDDATA_INCLUDE_CERT_OPTION_SELF;

//自定义常量

// 证书基本信息：
var NETCAPKI_CERT_PEM = 0;    //	NETCA为证书Base64编码
var NETCAPKI_CERT_THUMBPRINT = 1;    //	NETCA为证书姆印
var NETCAPKI_CERT_SERIALNUMBER = 2;  //	证书序列号
var NETCAPKI_CERT_SUBJECT = 3;       //	证书Subject
var NETCAPKI_CERT_ISSUER = 4;        //	证书颁发者
var NETCAPKI_CERT_VALIDFROMDATE = 5; //	证书有效期起
var NETCAPKI_CERT_VALIDTODATE = 6;   //	证书有效期止
var NETCAPKI_CERT_KEYUSAGE = 7;      //	密钥用法 KeyUsage
var NETCAPKI_CERT_PUBLICKEYALGO = 8;      //	证书公钥算法
var NETCAPKI_CERT_USRCERTNO = 9;     //	UsrCertNO：证书绑定号；//NETCA绑定姆印，编号为1；GDCA绑定为TrustID，编号为51；
var NETCAPKI_CERT_OLDUSRCERTNO = 10; // OldUsrCertNo：旧的用户证书绑定值；NETCA：绑定旧姆印，编号为31；GDCA：绑定为TrustID，编号为51；
// 证书基本信息细化解析：
var NETCAPKI_CERT_SUBJECT_NAME = 11; //	证书主题名称；有CN项取CN项值；无CN项，取O的值
var NETCAPKI_CERT_SUBJECT_CN = 12;   //	Subject中的CN项（人名）
var NETCAPKI_CERT_SUBJECT_O = 13;    //	Subject中的O项（单位）
var NETCAPKI_CERT_SUBJECT_L = 14;    //	Subject中的L项（地址）
var NETCAPKI_CERT_SUBJECT_EMAIL = 15; //	Subject中的Email
var NETCAPKI_CERT_SUBJECT_DEPARTMENT = 16; //	Subject中的部门名
var NETCAPKI_CERT_SUBJECT_COUNTRY = 17;   //	用户国家名
var NETCAPKI_CERT_SUBJECT_CITY = 18;      //	用户省州名
// 特定证书信息：
var NETCAPKI_CERT_CATITLE = 21;               //	CA ID： CA的ID:1：NETCA；2：GDCA；3：SZCA；0：未知CA
var NETCAPKI_CERT_CERTCLASSIFY = 22;      //	CertClassify：证书类型；1：服务器证书；2：个人证书 3: 机构证书；4：机构员工证书；5：机构业务证书；注：该类型国密标准待定0：其他证书
var NETCAPKI_CERT_CERTID = 23;            //	CertID；证书唯一标识； GDCA为信任号，见编号51 NETCA：目前无，以后可能有，兼容以后
// NETCA扩展域		
var NETCAPKI_CERT_PREVCERT_THUMBPRINT = 31; //	旧姆印信息（如保含该域，则取出，否则为“”）
var NETCAPKI_CERT_TAXPAYERNUM = 32;         //	纳税人编码（如保含该域，则取出，否则为“”）
var NETCAPKI_CERT_ENTERPRISENUM = 33;       //	企业法人代码（如保含该域，则取出，否则为“”）
var NETCAPKI_CERT_TAXREGISTERNUM = 34;       //	税务登记号（如保含该域，则取出，否则为“”）
var NETCAPKI_CERT_CERTFROM = 35;             //	证书来源地（如保含该域，则取出，否则为“”）
// GDCA扩展域		
var NETCAPKI_CERT_TRUSTID = 51;              //	GDCA的信任号TrustID

var initialObj = new ActiveXObject("NetcaPki.Utilities");
//全局统一入口

var NetcaPKI = (function(){
    
       //使用严格模式
	   "use strict";
        
        var PKIObject = {};

            //Certificate类
            function Certificate(inCertObject)
            {
          
                var _this=this;
                //下层的证书对象
                _this._cert=inCertObject;
                
                if(_this._cert==null)
                    return ;                  
                _this.publicKeyAlgorithm=_this._cert.PublicKeyAlgorithm;//公钥算法
                _this.issuer    =_this._cert.Issuer;//颁发者
                _this.issuerC   =_this._cert.IssuerC;//颁发者C
                _this.issuerST  =_this._cert.IssuerST;//颁发者ST
                _this.issuerL   =_this._cert.IssuerL;//颁发者L
                _this.issuerO   =_this._cert.IssuerO;//颁发者O
                _this.issuerOU  =_this._cert.IssuerOU;//颁发者OU
                _this.issuerCN  =_this._cert.IssuerCN;//颁发者CN        
                _this.subject   =_this._cert.Subject;//主体名
                _this.subjectC  =_this._cert.SubjectC;//主体名C
                _this.subjectST =_this._cert.SubjectST;//主体名ST
                _this.subjectL  =_this._cert.SubjectL;//主体名L
                _this.subjectO  =_this._cert.SubjectO;//主体名O
                _this.subjectOU =_this._cert.SubjectOU;//主体名OU
                _this.subjectCN =_this._cert.SubjectCN;//主体名CN
                _this.subjectEmail  =_this._cert.SubjectEmail;//主体名的Email项或者主体备用名的Email项
                _this.validFromDate =_this._cert.ValidFromDate;//有效期开始时间
                _this.validToDate   =_this._cert.ValidToDate;//有效期结束时间
                _this.publicKeyType =_this._cert.PublicKeyType;//公钥的类型
                _this.publicKeyBits =_this._cert.PublicKeyBits;;//公钥的长度
                _this.certClass    =_this._cert.CertClass;;//证书的类别
                _this.serialNumber  =_this._cert.SerialNumber;;//Hex编码的证书序列号
                _this.keyUsage      =_this._cert.KeyUsage;;//密钥用法
            }
            /*
            声明：
            function encode(type)
            参数：
                type：编码类型，可选参数，参见2.1.4。缺省值为DER编码
            返回值：
                返回证书编码。如果type为CERT_ENCODE_DER,则为字节数组，否则为字符串
            说明：
                获取证书的编码
            */
             Certificate.prototype.encode=function(type)
            {
                if(this._cert==null)
                    return null;
                            
                return this._cert.Encode(type);
            };
            /*
            声明：
            function display()
            参数：
                无
            返回值：
                无
            说明：
                显示证书
            */
            Certificate.prototype.display=function()
            {
                if(this._cert==null)
                    return null;
                            
                this._cert.Display();
            };
            /*声明：
            function getStringExtensionValue(extOid)
            参数：
                extOid：扩展的OID，字符串类型
            返回值：
                成功返回字符串扩展的值（字符串类型），没有该扩展返回空串””。
            说明：
                获取OID为extOid的字符串类型的扩展的值
            */
            Certificate.prototype.getStringExtensionValue=function(extOid)
            {
                if(this._cert==null)
                    return null;
                            
                return this._cert.GetStringExtension(extOid);
            };
            /*
            声明：
            function computeThumbprint (algo)
            参数：
                algo：Hash算法，参见2.1.5
            返回值：
                成功返回Hex编码的证书微缩图的值（字符串类型）
            说明：
                根据Hash算法计算证书的微缩图
            */
            Certificate.prototype.computeThumbprint=function(algo)
            {
                if(this._cert==null)
                    return null;
                             
                return NetcaPKI.hexEncode(this._cert.ThumbPrint(algo));
            };
            /*
            声明：
            function verifyPwd(pwd)
            参数：
                pwd：用户密码，字符串类型
            返回值：
                成功返回true，失败返回false
            说明：
                验证证书对应私钥的用户密码
            */
            Certificate.prototype.verifyPwd=function(pwd)
            {
                if(this._cert==null)
                    return null;
                    
                return  this._cert.VerifyPwd(pwd);              
            };
            /*声明：
            function match(expr)
            参数：
                expr：条件表达式，字符串类型
            返回值：
                匹配返回true，不匹配返回false
            说明：
                验证证书是否符合某些条件
            */
            Certificate.prototype.match=function(expr)
            {
                if(this._cert==null)
                    return null;
                //todo：如果匹配返回1，不匹配返回0，表达式错误返回-1,处理出错返回-2
                var ret= this._cert.Match(expr);    
                if(ret==1)
                {
                    return true;
                }
                return   false;         
            };
            
            /*
            声明：
            function getIntegerAttribute (attrId)
            参数：
                attrId：证书属性ID，参见2.16
            返回值：
                返回证书整数类型的属性（返回值为数字类型）
            说明：
                获取整数类型的属性值
            */
            Certificate.prototype.getIntegerAttribute=function(attrId)
            {
                if(this._cert==null)
                    return null;
        
                return  this._cert.GetIntInfo(attrId);    
                    
            };   
            
            /*
            声明：
            function equalCert (cmpcert)
            参数：
                cmpcert. 比较的证书certificate
            返回值：
                一样返回true，否则返回false
            说明：
                判断证书是否一样
            */
            Certificate.prototype.equalCert=function(cmpcert)
            {
                if(this._cert==null)
                   return null;
             
                if(cmpcert==null)
                   return false;
                   
                return  this._cert.Equal(cmpcert._cert);    
                    
            };   
            /*
            声明：
            function getStringAttribute (attrId)
            参数：
                attrId：证书属性ID，参见2.16
            返回值：
                返回证书字符串类型的属性（返回值为字符串类型），如果是字符串数组类型的，取第一个
            说明：
                获取证书字符串类型的属性
            */
            Certificate.prototype.getStringAttribute=function(attrId)
            {
                if(this._cert==null)
                    return null;
        
                return  this._cert.GetStringInfo(attrId);    
                    
            };  
            
        /* 声明：
            function getStringArrayAttribute (attrId)
            参数：
                attrId：证书属性ID，参见2.16
            返回值：
                返回证书字符串数组类型的属性（返回值为字符串组成的数组），如果是字符串数组类型的，返回包含1个字符串的字符串数组
            说明：
                获取证书字符串数组类型的属性
            */
            Certificate.prototype.getStringArrayAttribute=function(attrId)
            {
                if(this._cert==null)
                    return null;
                    
                var index=1;
                var comArray=this._cert.GetStringArrayInfo(attrId); 
                var stringArray= new Array();            
                var arrayLength=NetcaPKI._baseObject.GetStringArrayLength(comArray);
                for(index=1;index<=arrayLength;++index)
                {
                    stringArray.push(NetcaPKI._baseObject.GetStringArrayData(comArray,index));
                }

                return  stringArray;
                    
            };  
            /*声明：
            function getHashAttribute (algo,attrId)
            参数：
                algo：Hash算法，参见2.1.5
                attrId：证书属性ID，参见2.16
            返回值：
                返回Hex编码的证书Hash类型的属性（字符串类型）
            说明：
                获取证书Hash类型的属性 
            */
            Certificate.prototype.getHashAttribute=function(algo,attrId)
            {
                if(this._cert==null)
                    return null;
          
                 return NetcaPKI.hexEncode(this._cert.GetHashStringInfo(algo,attrId));
                    
            };  
 
            
        //Certificates类      
        function Certificates()
        {
            this._array= new Array();
            this.length=0;
        }
        /*
        模仿索引访问实现
        */
        Certificates.prototype.resetIndexArray=function()
        {
            var i=0;
            if(this.length>this._array.length)
            {
                for(i=0;i<this.length;++i)
                {
                    this[i]=null;
                }
            }
            this.length=this._array.length;
            for(i=0;i<this.length;++i)
            {
                this[i]=this._array[i];
            }
        }
        
        Certificates.prototype.push_back=function(data)
        {    
            
            this._array.push(data);       
            this.resetIndexArray();      
        }
        /*
        声明：
        function filter(expr)
        function filter(func)
        function filter(name,value[,op])
        function filter(name,valueArray[,op])
        参数：
            expr:字符串类型，是个表达式，如果证书符合则留下
            func:函数，有一个Certificate类型的参数，如果func(cert)返回真，则留下
            name：名称，字符串类型
            value：值，根据名称的不同可以是布尔类型也可以是字符串类型。
            valueArray：数组类型，多个值之间是或的关系
            op：过滤 表达式比较操作，可选参数，参见2.17，缺省为相等
        返回值：
            返回符合条件的Certificates
        说明：
            根据一定条件过滤证书
        */
        Certificates.prototype.filter=function(ExprOrFunOrName,valueOrArray,op)
        {    
            var tmpArray= new Certificates();
            var index=0;
            
            if (typeof valueOrArray === "undefined") 
            { 
                /*
                function filter(expr)
                */           
                if (typeof ExprOrFunOrName==="string") 
                {
                   
                        for(index=0;index<this.length;++index)
                        {
                            if(this[index].match(ExprOrFunOrName))
                            {
                                tmpArray.push_back(this[index]);
                            }
                        }
                        return tmpArray;
                    
                }
                else  if(typeof ExprOrFunOrName==="function")
                {
                        //function filter(func)
               
                        for(index=0;index<this.length;++index)
                        {
                            if(ExprOrFunOrName(this[index]))
                            {
                                tmpArray.push_back(this[index]);
                            }
                        }
                        
                        return tmpArray;
                }
                
                tmpArray=null;
                return null;
            
        }
            
        if(true)
        {
                                        
                /* function filter(name,value[,op])
                function filter(name,valueArray[,op])
                */
                    var  exprString="";
                    var  OperType="";
                    var  bMustNegation=false;
                    var  bMatch=false; 
                    var  bFirsrt=true;
                    
                    if(ExprOrFunOrName=="")
                    {
                        return tmpArray;
                    }
                    
                    if(typeof op === "undefined"||op==NetcaPKI.CONDITION_TYPE_EQUAL)
                    {
                        OperType="=";
                    }
                    else if(op==NetcaPKI.CONDITION_TYPE_NOT_EQUAL)
                    {
                        //结果取反操作
                        bMustNegation=true;
                        OperType="=";
                    }
                    else if(op==NetcaPKI.CONDITION_TYPE_CONTAIN)
                    {
                        OperType="~";
                    }
                    else if(op==NetcaPKI.CONDITION_TYPE_NOT_CONTAIN)
                    {
                        //结果取反操作
                        bMustNegation=true;
                        OperType="~";
                    }
            
                    if(typeof valueOrArray==="string")
                    {                              
                        exprString+=ExprOrFunOrName;
                        exprString+=OperType;
                        exprString+="'";
                        exprString+=valueOrArray;
                        exprString+="'";
                
                    }
                    else
                    {
                       
                        for(index=0;index<valueOrArray.length;++index)
                        {
                            if(valueOrArray[index]!="")
                            {
                                    if(bFirsrt)
                                    {                                      
                                        bFirsrt=false;
                                    }
                                    else
                                    {
                                        exprString+="||";
                                    }
                                    exprString+=ExprOrFunOrName;
                                    exprString+=OperType;
                                    exprString+="'";
                                    exprString+=valueOrArray[index];
                                    exprString+="'";
                                
                            }
                        }
                        
                    } 
                    
                    for(index=0;index<this.length;++index)
                    {
                        
                        bMatch=this[index].match(exprString);                            
                        bMatch=bMustNegation?!bMatch:bMatch;
                        if(bMatch)
                        {
                            tmpArray.push_back(this[index]);
                        }
                    }
                   
                    return tmpArray;  
                
                }
                
            tmpArray=null;
            return null;

        }
        
        
    
        /*声明：
        function select([expr],[uiFlag])
        function select([func],[uiFlag])
        参数：
            expr:字符串类型，是个表达式，如果证书符合则留下。可选参数，缺省为全部符合
            func:函数，有一个Certificate类型的参数，如果func(cert)返回真，则留下。可选参数，缺省为全部符合
            uiFlag：弹出UI的方式，参见2.1.8
        返回值：
            成功返回选择的证书(Certificate类型)，没有证书选择返回null
        说明：
            选择证书
        */
        Certificates.prototype.select=function(ExprOrFun,uiFlag)
        { 
            var flag=NetcaPKI.UIFLAG_DEFAULT_UI;
            var filter="";
            if(ExprOrFun==null)
            {
                return null;
            }
            
            if(uiFlag!=null)
            {      
                flag=uiFlag;
            }
            
            var store=NetcaPKI._baseObject.CreateStoreObject();
                store.open(NetcaPKI.CERT_STORE_TYPE_MEMORY,"");
                
            if(typeof ExprOrFun==="function")
            {
                for(var index=0;index<this.length;++index)
                {
                    if(ExprOrFun(this[index]))
                    {
                        store.Add(this[index]._cert);
                    }
                }            
        
            }
            else if(typeof ExprOrFun==="string")
            {
              
                filter=ExprOrFun;     
                
                for(var index=0;index<this.length;++index)
                {
                    store.Add(this[index]._cert);              
                }  
                        
            }
            var pVal=store.FindCertificate(filter,flag);
            store.close();
            store=null;
            if(pVal==null)
            {
                return null;
            }
            
            return  new Certificate(pVal);
        }
        /*声明：
        function union(certs)
        参数：
            certs:另一个Certificates对象
        返回值：
            返回合并后的Certificates对象
        说明：
            把两个Certificates对象里的证书合起来构造成一个新的Certificates对象
        */
        Certificates.prototype.union=function(certs)
        { 
            var index=0;
            var indexCerts=0;
            if(certs==null)
            {
                return null;
            }
            var  tmpArray= new Certificates();
            for(index=0;index<this.length;++index)
            {
                    tmpArray.push_back(this[index]);              
            }  
            
            for(indexCerts=0;indexCerts<certs.length;++indexCerts)
            {
                    tmpArray.push_back(certs[indexCerts]);              
            }  
            
            return tmpArray;
        }
        /* 
        声明：
        function unique()
        参数：
            无
        返回值：
            返回原来Certificates中不重复的证书构成的新的Certificates对象
        说明：
            去掉Certificates对象里的重复的证书
        */
        Certificates.prototype.unique=function()
        { 
            var indexCerts=0;
            var bRepeat=false;
            var tmpArray= new Certificates(); 
            var index=0;
            var indexCerts=0;
            
            if(this.length<=0)
            {
                return tmpArray;
            }           
            
            for(index=0;index<this.length;++index)
            {
                    bRepeat=false;
                    for(indexCerts=0;indexCerts<tmpArray.length;++indexCerts)
                    {
                        if(tmpArray[indexCerts].equalCert(this[index]))
                        {
                            bRepeat=true;
                            break;
                        }
                    }                          
                                            
                    if(!bRepeat)
                    {
                       tmpArray.push_back(this[index]);
                    }
                    
                                
            }  
            
            return tmpArray;
        }
        
        
        /*声明：
        function thumbprint (hashAlgo,value)
        参数：
            hashAlgo：Hash算法，参见2.1.5
            value：Hex编码的微缩图的值，字符串类型
        返回值：
            返回微缩图匹配的证书组成的Certificates对象
        说明：
            根据微缩图进行过滤
        */
        Certificates.prototype.thumbprint=function(hashAlgo,value)
        { 
            if (typeof value === "undefined"||value=="")
            {
                return null;
            }
            var  tmpArray= new Certificates();
            var index=0;
            var cmpValue=value.toLowerCase();
            for(index=0;index<this._array.length;++index)
            {
                
                var littleThumbPrint=this[index].computeThumbprint(hashAlgo)
                
                if(littleThumbPrint==null)
                {
                    continue;
                }
                if(littleThumbPrint==cmpValue)
                {
                    tmpArray.push_back(this[index]); 
                }
                littleThumbPrint=null;             
            }  
            
            return tmpArray;
        }
        /*
        声明：
        function hasExtension (extOid,[value])
        参数：
            extOid:扩展的OID, 字符串类型
            value：扩展的值，字符串类型，可选。如果不存在，只需要存在扩展就匹配，否则要匹配值
        返回值：
            返回扩展匹配的证书组成的Certificates对象
        说明：
            根据扩展进行过滤
        */
        Certificates.prototype.hasExtension=function(extOid,value)
        { 
            
            var tmpArray= new Certificates();
            var index=0;
            var exprString="";
            if (typeof value === "undefined" ) 
            {   
                exprString="HasExt='";
                exprString+=extOid;
                exprString+="'";
            }
            else
            {
                exprString="ExtValue#";
                exprString+=extOid;
                exprString+="='";
                exprString+=value;
                exprString+="'";
            }
                
            for(index=0;index<this.length;++index)
            {             
                if(this[index].match(exprString))
                {
                    tmpArray.push_back(this._array[index]); 
                }
                        
            }  
            
            return tmpArray;
        }

        
       
        
        try
        {
            PKIObject._baseObject= new ActiveXObject("NetcaPki.Utilities");
        }
        catch(e)
        {
            alert("创建NetcaPki对象失败!");
            return PKIObject;
        }
        
        
        
      function initializeObject(obj)
      {   
            /*
            常量
            */
            //2.1.1公钥类型
            obj.PUBLICKEY_TYPE_RSA=1;//SA类型的公钥
            obj.PUBLICKEY_TYPE_SM2=2;//SM2类型的公钥
            obj.PUBLICKEY_TYPE_ECC=3;//非SM2类型的ECC公钥
            //2.1.2 证书的类别     
            obj.CERT_CLASS_SELFSIGN  =1 ;//自签证书
            obj.CERT_CLASS_SELFISSUER=2	;//自颁发证书
            obj.CERT_CLASS_CA	     =3;//CA证书
            obj.CERT_CLASS_TSA		 =4;//TSA证书
            obj.CERT_CLASS_OCSP		 =5;//OCSP证书
            obj.CERT_CLASS_ORGANIZATION=6;//机构证书
            obj.CERT_CLASS_BUSINESS	=7;//业务证书
            obj.CERT_CLASS_EMPLOYEE	=8;//单位员工证书
            obj.CERT_CLASS_INDIVIDUAL	=9;//	自然人证书
            obj.CERT_CLASS_SERVER	=10	;//服务器证书
            obj.CERT_CLASS_SMIME	=11	;//S/MIME证书
            obj.CERT_CLASS_CODESIGN	=12	;//代码签名证书
            obj.CERT_CLASS_OTHER	=0	;//其他证书
            /*2.1.3 密钥用法
            密钥用法是逐位或的。
            */
            obj.KEYUSAGE_DIGITALSIGNATURE =1;	//签名
            obj.KEYUSAGE_NONREPUDIATION	  =2;	//不可否认
            obj.KEYUSAGE_CONTENTCOMMITMENT	=2;	//不可否认
            obj.KEYUSAGE_KEYENCIPHERMENT	=4;	//加密密钥
            obj.KEYUSAGE_DATAENCIPHERMENT	=8;	//加密数据
            obj.KEYUSAGE_KEYAGREEMENT	=16;	//密钥协商
            obj.KEYUSAGE_KEYCERTSIGN	=32;	//签证书
            obj.KEYUSAGE_CRLSIGN	=64;	//签CRL
            obj.KEYUSAGE_ENCIPHERONLY	=128;	//密钥协商中的只加密
            obj.KEYUSAGE_DECIPHERONLY	=256;	//密钥协商中的只解密
            /*2.1.4 证书的编码类型：*/  
            obj.CERT_ENCODE_DER	=1;	//DER编码
            obj.CERT_ENCODE_BASE64	=2;	//带头和尾的Base64编码
            obj.CERT_ENCODE_BASE64_NO_NL	=3;	//不分行的Base64编码
            /*2.1.5 Hash算法*/           
            obj.MD5	=0x1000;	//MD5算法
            obj.SHA1	=0x2000;	//SHA-1算法
            obj.SHA224	=0x3000;	//SHA-224算法
            obj.SHA256	=0x4000;	//SHA-256算法
            obj.SHA384	=0x5000;	//SHA-384算法
            obj.SHA512	=0x6000;	//SHA-512算法
            obj.SM3	=0x7000;	//SM3算法
            obj.SHA512_224	=0x8000;	//SHA-512/224算法
            obj.SHA512_256	=0x9000;	//SHA-512/256算法
            obj.SHA3_224	=0xA000;	//SHA3-224算法
            obj.SHA3_256	=0xB000;	//SHA3-256算法
            obj.SHA3_384	=0xC000;	//SHA3-384算法
            obj.SHA3_512	=0xD000;	//SHA3-512算法
            /*2.1.6 证书属性*/
 
            obj.CERT_ATTRIBUTE_PRIVKEY_ATTRIBUTE	=1;	//私钥属性，内部使用，不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_VERSION	=2;	//版本号，整型，只读
            obj.CERT_ATTRIBUTE_SIGNALGO	=3;	//签名算法，整型，只读
            obj.CERT_ATTRIBUTE_PUBKEYALGO	=4;	//公钥算法，整型，只读
            obj.CERT_ATTRIBUTE_PUBKEYBITS	=5;	//公钥的位数，整型，只读
            obj.CERT_ATTRIBUTE_KEYUSAGE	=6;	//密钥用法，整型，只读
            obj.CERT_ATTRIBUTE_HAS_PRIVKEY_ATTRIBUTE	=7;	//是否有私钥属性，整型，不在证书编码里，只读
            obj.CERT_ATTRIBUTE_ISSUER	=8;	//颁发者，字符串类型，只读
            obj.CERT_ATTRIBUTE_ISSUER_DISPLAY_NAME	=9;	//颁发者的显示名，字符串类型，只读。如果颁发者有CN则是最后一个CN，有OU则是最后一个OU，有O则是最后一个O，否则是最后一个颁发者项，如果不存在颁发者项则为第一个颁发者备用名
            obj.CERT_ATTRIBUTE_ISSUER_C	=10;	//颁发者的C值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_O	=11;	//颁发者的O值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_OU	=12;	//颁发者的OU值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_CN	=13;	//颁发者的CN值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_EMAIL	=14;	//颁发者的Email值，字符串类型。包含颁发者备用名称里的Email值。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT	=15;	//主体，字符串类型，只读
            obj.CERT_ATTRIBUTE_SUBJECT_DISPLAY_NAME	=16;	//主体的显示名，字符串类型，只读。如果主体有CN则是最后一个CN，有OU则是最后一个OU，有O则是最后一个O，否则是最后一个主体项，如果不存在主体项则为第一个主体备用名
            obj.CERT_ATTRIBUTE_SUBJECT_C	=17;	//主体的C值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_O	=18;	//主体的O值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_OU	=19;	//主体的OU值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_CN	=20;	//主体的CN值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_EMAIL	=21;	//主体的Email值，字符串类型。包含主体用名称里的Email值。可能多值，只读
            obj.CERT_ATTRIBUTE_EX_FRIENDLY_NAME	=22;	//好记的名字，字符串类型。不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_EX_NAME	=23;	//证书拥有者的名称，字符串类型。不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_EX_ORGANIZATION	=24;	//证书拥有者的单位，字符串类型。不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_EX_DEPARTMENT	=25;	//证书拥有者的部门，字符串类型。不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_EX_EMAIL	=26;	//证书拥有者的Email，字符串类型。不在证书编码里。可能多值，可读可写
            obj.CERT_ATTRIBUTE_GET_KEYPAIR_HADNLE_NEED_PWD = 27;	//	获取私钥是否需要密码，证书类型，不在证书编码里，只读
            obj.CERT_ATTRIBUTE_KEYPAIR_HADNLE	=28;	//私钥句柄，内部使用，不在证书编码里，可读可写
            obj.CERT_ATTRIBUTE_PREVCERT_THUMBPRINT=	29;	//更新前的证书的姆印，字符串类型。只读
            obj.CERT_ATTRIBUTE_VALIDITY_START=	30;	//证书的有效期开始时间，字符串类型。格式为YYYYMMDDhhmmssZ或者YYYYMMDDhhmmss.xxxZ的UTC时间，只读
            obj.CERT_ATTRIBUTE_VALIDITY_END	=31;	//证书的有效期结束时间，字符串类型。格式为YYYYMMDDhhmmssZ或者YYYYMMDDhhmmss.xxxZ的UTC时间，只读
            obj.CERT_ATTRIBUTE_SN_DEC	=32;	//10进制的证书序列号，字符串类型。只读
            obj.CERT_ATTRIBUTE_SN_HEX	=33;	//HEX编码的证书序列号，字符串类型。只读
            obj.CERT_ATTRIBUTE_IN_VALIDITY	=34;	//证书是否在有效期内，整型，只读
            obj.CERT_ATTRIBUTE_PRIVATE_ISCSP	=35;	//证书的私钥是否是使用CSP，整型，不在证书编码里，只读
            obj.CERT_ATTRIBUTE_UPN	=36;	//证书的UPN，字符串类型。只读
            obj.CERT_ATTRIBUTE_ISSUER_ST	=37;	//颁发者的ST值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_L	=38;	//颁发者的L值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_ST	=39;	//主体的ST值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_L	=40;	//主体的L值，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_EX_DEVICE_TYPE=	41;	//证书对应私钥的设备的类型，整型，不在证书编码里，只读
            obj.CERT_ATTRIBUTE_EX_DEVICE_SN	=42;	//证书对应私钥的设备的序列号，字符串类型，不在证书编码里，只读
            obj.CERT_ATTRIBUTE_PUBKEY_ECC_CURVE	=43;	//ECC证书的曲线号，整型，只读
            obj.CERT_ATTRIBUTE_THUMBPRINT	=44;	//证书的微缩图，Hash值
            obj.CERT_ATTRIBUTE_HASH_ISSUER	=45;	//证书的颁发者的编码的Hash值，Hash值。
            obj.CERT_ATTRIBUTE_HASH_SUBJECT	=46;	//证书的主体的编码的Hash值，Hash值。
            obj.CERT_ATTRIBUTE_HASH_PUBKEY	=47;	//证书的公钥的编码的Hash值，Hash值。
            obj.CERT_ATTRIBUTE_ISSUER_LDAP_NAME	=48;	//证书颁发者名的LDAP表示，字符串类型。只读
            obj.CERT_ATTRIBUTE_ISSUER_XMLSIG_NAME	=49;	//证书颁发者名的XML签名要求的字符串表示，字符串类型。只读
            obj.CERT_ATTRIBUTE_SUBJECT_LDAP_NAME	=50;	//证书主体名的LDAP表示，字符串类型。只读
            obj.CERT_ATTRIBUTE_SUBJECT_XMLSIG_NAME	=51;	//证书主体名的XML签名要求的字符串表示，字符串类型。只读
            obj.CERT_ATTRIBUTE_SUBJECT_HEX_ENCODE	=52;	//证书主体的DER编码再Hex编码，字符串类型，只读
            obj.CERT_ATTRIBUTE_ISSUER_HEX_ENCODE	=53;	//证书颁发者的DER编码再Hex编码，字符串类型，只读
            obj.CERT_ATTRIBUTE_CHECK_PRIVKEY	=54;	//不验证密码连接设备检测是否存在密钥对。整型，只读
            obj.CERT_ATTRIBUTE_CSP_NAME	=55;	//私钥对应的CSP名称，字符串类型，只读
            obj.CERT_ATTRIBUTE_CRL_URL	=56;	//证书CRL发布点扩展里的URL，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_DELTA_CRL_URL	=57;	//证书FreshCRL扩展里的URL，字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_OCSP_URL	=58;	//证书AIA扩展里的OCSP URL。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_IP	=59;	//主体备用名里的IP地址。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_DNS_NAME	=60;	//主体备用名里的DNS。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_CERT_POLICY_OID	=61;	//证书策略OID。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_EXTENDED_KEY_USAGE	=62;	//扩展密钥用法OID。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_HASH_SUBJECT_PUBKEY_INFO	=63;	//主体公钥信息的DER编码的Hash, Hash值。
            obj.CERT_ATTRIBUTE_SMIMECAPABILITIES	=65;	//SmimeCapabilities扩展。字符串类型，只读。是个JSON数组，每个项是个数组，数组里的有一到两项，第一项为字符串，OID。第二项如果存在的话，为字符串，参数的Hex编码。
            obj.CERT_ATTRIBUTE_SUBJECT_KEYID	=66;	//主体密钥标识符的Hex编码。字符串类型，只读。
            obj.CERT_ATTRIBUTE_ISSUER_DN_QUALIFIER	=67;	//颁发者的DN Qualifier。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_SUBJECT_DN_QUALIFIER	=68;	//主体的DN Qualifier。字符串类型。可能多值，只读
            obj.CERT_ATTRIBUTE_ISSUER_SN	=69;	//颁发者的序列号。字符串类型。可能多值，只读。注意：不是证书的序列号
            obj.CERT_ATTRIBUTE_SUBJECT_SN	=70;	//主体的序列号。字符串类型。可能多值，只读。注意：不是证书的序列号
            obj.CERT_ATTRIBUTE_ISSUER_TITLE	=71;	//颁发者的Title。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_TITLE	=72;	//主体的Title。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_SURNAME	=73;	//颁发者的surname。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_SURNAME	=74;	//主体的surname。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_GIVEN_NAME	=75;	//颁发者的given name。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_GIVEN_NAME	=76;	//主体的given name。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_INITIALS	=77;	//颁发者的initials。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_INITIALS	=78;	//主体的initials。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_PSEUDONYM	=79;	//颁发者的pseudonym。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_PSEUDONYM	=80;	//主体的pseudonym。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_GENERATION_QUALIFIER	=81;	//颁发者的generation qualifier。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_GENERATION_QUALIFIER	=82;	//主体的generation qualifier。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_DC	=83;	//颁发者的DC。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_DC	=84;	//主体的DC。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_UID	=85;	//颁发者的UID。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_UID	=86;	//主体的UID。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_STREET	=87;	//颁发者的street。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_STREET	=88;	//主体的street。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_CAISSUERS_URL	=89;	//颁发者证书的URL，字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_JURISDICTION_L	=90;	//主体的管辖地的L, 字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_JURISDICTION_ST	=91;	//主体的管辖地的ST, 字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_JURISDICTION_C	=92;	//主体的管辖地的C, 字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_SUBJECT_BUSINESS_CATEGORY	=93;	//主体的business category, 字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_GB_IDENTITY_CODE	=94;	//国标的个人身份识别码。字符串类型。只读
            obj.CERT_ATTRIBUTE_CRICAL_EXTENSIONS	=95;	//所有的关键扩展的OID。字符串类型。可能多值，只读。
            obj.CERT_ATTRIBUTE_ISSUER_AND_SERIALNUMBER	=96;	//颁发者名和序列号的DER编码后再Hex编码。字符串类型。只读
            obj.CERT_ATTRIBUTE_ISSUER_REVERSE	=97;	//反序的颁发者。字符串类型。只读
            obj.CERT_ATTRIBUTE_SUBJECT_REVERSE	=98;	//反序的主体。字符串类型。只读
            obj.CERT_ATTRIBUTE_CERT_CLASS	=99;	//证书的类别。整型，只读。参见4.1.58
            obj.CERT_ATTRIBUTE_CERT_CLASS_EXT_VALUE	=100;	//1.3.6.1.4.1.18760.1.12.12.2证书类别扩展的值，字符串类型。只读
            obj.CERT_ATTRIBUTE_SHENZHEN_SUBJECT_UNIQUE_ID	=101;	//2.16.156.112548深圳地标用户唯一标识的值，字符串类型。只读
            obj.CERT_ATTRIBUTE_NETCA_SUBJECT_UNIQUE_ID	=102;	//1.3.6.1.4.1.18760.1.12.11NETCA用户唯一标识的值，字符串类型。只读
            obj.CERT_ATTRIBUTE_KEYPAIR_INFO_STRING	=103;	//证书相关密钥对的连接信息的字符串表示，字符串类型。只读
     
            /*2.1.7 过滤表达式比较操作*/           
            obj.CONDITION_TYPE_EQUAL	=1;	//相等
            obj.CONDITION_TYPE_NOT_EQUAL	=2;	//不等
            obj.CONDITION_TYPE_CONTAIN	=3;	//包含
            obj.CONDITION_TYPE_NOT_CONTAIN	=4;	//不包含  
            /*2.1.7弹出UI的方式*/          
            obj.UIFLAG_DEFAULT_UI	=1;	//没有或者仅有一个不弹对话框选择
            obj.UIFLAG_NO_UI	=2;	//从不弹对话框选择，如果不是仅有一个返回null
            obj.UIFLAG_ALWAYS_UI	=3;	//总是弹对话框选择          
            /*2.1.8用户证书的类型*/
            //可以或起来使用            
            obj.GET_USERCERT_TYPE_ENCRYPT	=1;//解密证书
            obj.GET_USERCERT_TYPE_SIGN	=2;	   //签名证书        
                
            /*2.1.9 SignedData验证的结果*/      
            obj.SUCCESS	=1;	//成功
            obj.FAIL	=0;//失败
            obj.VERIFY_SIGNEDDATA_PARTLY_FAIL	=-32;	//验证SignedData时，至少一个签名成功，但存在验证签名的签名
            obj.VERIFY_SIGNEDDATA_CERT_FAIL	=-36;	//验证SignedData的证书失败
            obj.SIGNEDDATA_BAD_DATA	=-41;	//SignedData格式错误
            obj.SIGNEDDATA_VERIFY_CONTENT_TYPE_FAIL	=-42;	//验证SignedData的Content-Type失败
            obj.SIGNEDDATA_VERIFY_HASH_FAIL	=-43;	//验证SignedData的Hash失败
            obj.SIGNEDDATA_VERIFY_SIGNATURE_FAIL	=-44;	//验证SignedData的签名失败
            obj.SIGNEDDATA_NO_MATCH_CERT	=-45;	//没有签名证书用于验证SignedData的签名
            obj.SIGNEDDATA_TBS_MISMATCH	=-84;	//SignedData的原文不匹配
            obj.SIGNEDDATA_SIGNEDCERT_MISMATCH	=-85;	//SignedData的签名证书不匹配
            obj.SIGNEDDATA_UNACCEPTABLE_SIGNALGO	=-86;	//不可接受的SignedData签名算法
            obj.SIGNEDDATA_OUTER_CONTENTINFO_MISMATCH	=-87;	//SignedData的ContentInfo不匹配
            obj.SIGNEDDATA_UNACCEPTABLE_SIGNINGCERT_ATTRIBUTE	=-88;	//不可接受的SigningCert属性                    
            /*2.1.10 签名算法*/            
            obj.SHA1WITHRSA	=2;	//SHA1WthRSA签名算法
            obj.SHA224WITHRSA	=3;//	SHA224WthRSA签名算法
            obj.SHA256WITHRSA	=4;//	SHA256WthRSA签名算法
            obj.SHA384WITHRSA	=5;//	SHA384WthRSA签名算法
            obj.SHA512WITHRSA	=6;	//SHA512WthRSA签名算法
            obj.SM3WITHSM2	=25;//SM3WithSM2签名算法           
            /*2.1.11 数字信封的对称加密算法*/           
            obj.AES128CBC	=4;	//AES-128
            obj.AES192CBC	=5;//AES-192
            obj.AES256CBC	=6;	//AES-256
            obj.SM4CBC	=9;	//SM4            
            /*2.1.12 SignedData的包含证书的选项*/           
            obj.INCLUDE_CERT_OPTION_NONE	=1	;//不包含任何证书
            obj.INCLUDE_CERT_OPTION_SELF	=2	;//仅包含签名的证书
            obj.INCLUDE_CERT_OPTION_CERTPATH	=3;	//包含整个证书链，不包含根证书
            obj.INCLUDE_CERT_OPTION_CERTPATHWITHROOT	=4;	//包含整个证书链，且包含根证书
            
            /*2.1.13 密码缓存选项*/
            
            obj.NO_CACHE_PWD	=1;	//不缓存密码
            obj.CACHE_PWD	=0;	//缓存密码
            obj.NO_CACHE_PWD_AND_CLEAR_CACHE	=-1;	//不缓存密码，且清掉以前的缓存
            /*2.1.14 证书的状态*/            
            obj.CERT_STATUS_UNREVOKED	=1;	//证书有效
            obj.CERT_STATUS_UNDETERMINED	=-1;	//证书的状态不能确定
            obj.CERT_STATUS_REVOKED	 =0	;//证书已作废
            obj.CERT_STATUS_CA_REVOKED	=-2;	//上级CA证书已作废
            obj.CERT_STATUS_NOT_IN_VALIDITY	=-100;	//证书不在有效期内
            obj.CERT_STATUS_BULID_CERTPAT_FAIL	=-101;	//没有安装证书链
            obj.CERT_STATUS_VERIFY_CERTPATH_FAIL	=-102;	//验证证书链失败
            obj.CERT_STATUS_NO_REVOKE_INFO	=-103;	//没有合适的作废信息
            obj.CERT_STATUS_ON_HOLD	=-104;	//证书已挂失           
            /*2.1.15 验证证书的标识*/
            /*或起来使用。
            0为仅仅验证证书路径，不验证证书的作废状态*/           
            obj.CERT_VERIFY_FLAG_VERIFY_REVOKE	=1;	//验证作废状态
            obj.CERT_VERIFY_FLAG_ONLINE	=2;	//在线获取作废信息
            obj.CERT_VERIFY_FLAG_VERIFY_CACERT_REVOKE	=4;	//验证CA证书的作废状态
            obj.CERT_VERIFY_FLAG_VERIFY_OCSP	=0x10;	//通过OCSP验证证书的作废状态
            obj.CERT_VERIFY_FLAG_VERIFY_CRL	=0x20;	//通过CRL验证证书的作废状态
            
            
            obj.BASE64_NO_NL	=1;
            obj.BASE64_STRICT	=2;
             
            //证书库类型
            obj.CERT_STORE_TYPE_CURRENT_USER=0;
            obj.CERT_STORE_TYPE_LOCAL_MACHINE=	1;
            obj.CERT_STORE_TYPE_MEMORY	=		2;
            
            obj.CERT_STORE_NAME_MY	=	"my";
            obj.CERT_STORE_NAME_OTHERS="others";
            obj.CERT_STORE_NAME_CA	=	"ca";
            obj.CERT_STORE_NAME_ROOT	="root";
            obj.CERT_STORE_NAME_DEVICE  ="device";
            
            obj.OK	=0;	//调用成功
            //设备密码类型
            obj.USER_PWD=1;
            obj.SO_PWD=2;

          try{

             obj._baseObject.SetErrorMode(false);

            }
            catch(e)
            {
                if(-2146827850==e.number)
                {   
                    //对象不支持此属性或方法
                    alert("当前NETCA_Crypto版本可能过低,请确保版本高于2.0");
                }
                
            }
   }
   
    /*
    声明：
    function decodeCert (data)
    参数：
        data：证书的编码，可以是Byte数组，也可以是字符串类型
    返回值：
        成功返回Certificate对象，失败返回null
    说明：
        根据证书的编码构造Certificate对象
    */
   
    PKIObject.decodeCert=function(data)
    {
         
      var inCert= PKIObject._baseObject.DecodeCert(data);
      
      if(inCert==null)
      {
            return null;
      }
      
      return new Certificate(inCert);
    }
   
    /* 声明：
    function getUserCert (type[,expr])
    参数：
        type：用户证书的类型，参见2.1.8
        expr：过滤表达式，字符串类型，可选参数，缺省为默认的过滤条件，通常为NETCA的证书
    返回值：
        成功返回Certificate对象，失败返回null
    说明：
        弹出对话框选择用户证书，得到Certificate对象
    */
    PKIObject.getUserCert=function(type,expr)
    {     
        var inCert;
        try
        {
            inCert= PKIObject._baseObject.getUserCert(type,expr);
        }
        catch(e)
        {
            //#define NETCA_PKI_USER_CANCEL		-18
            //var  errorCode=NetcaPKI.getLastError();
            if(NetcaPKI.getLastError()==(-2147044370))
            {
                 return null;
            }
            else
            {
                 throw new Error(e.number,NetcaPKI.getLastErrorMsg());
            }
        }
        
        if(inCert==null)
        {
            return null;
        }
        
        return new Certificate(inCert);
    }
    
    /*  声明：
    function getCertsFromStore ()
    参数：
        无
    返回值：
        成功返回个人证书库里所有证书组成的Certificates对象，失败返回null
    说明：
        根据当前用户的个人证书库构造Certificates对象
    */
    PKIObject.getCertsFromStore=function()
    {
        var n = 1;
        var store = PKIObject._baseObject.CreateStoreObject();
        //NETCAPKI_CERT_STORE_TYPE_CURRENT_USER 0
        store.Open(NetcaPKI.CERT_STORE_TYPE_CURRENT_USER,NetcaPKI.CERT_STORE_NAME_MY);
        
        var certCount = store.GetCertificateCount();
   
        var certArray = new Certificates();
        var cert ;
        for(n = 1; n <= certCount; ++n)
        {
            cert = store.GetCertificate(n);
            certArray.push_back(new Certificate(cert));
        }
        
        store.close();
        store=null;
        if(certArray.length<=0)
        {
            certArray=null;
            return null;
        }   
        return certArray;
    }
  
    
    /*  声明：
    function getCertsFromDevice()
    参数：
        无
    返回值：
        成功返回设备里所有证书组成的Certificates对象，失败返回null
    */
    PKIObject.getCertsFromDevice=function()
    {
         
         var n = 1;
        var store = PKIObject._baseObject.CreateStoreObject();
        store.Open(NetcaPKI.CERT_STORE_TYPE_CURRENT_USER,NetcaPKI.CERT_STORE_NAME_DEVICE);
        
        var certCount = store.GetCertificateCount();    
        var certArray = new Certificates();
        var cert;
        for(n = 1; n <= certCount; ++n)
        {
            cert = store.GetCertificate(n);
            certArray.push_back(new Certificate(cert));
        }
        
        store.close();
        store=null;
        if(certArray.length<=0)
        {
            certArray=null;
            return null;
        }   
        return certArray;
    }  
    
    /*声明：
    function getCerts(certs)
    参数：
        certs:Certificate数组，可以为空数组
    返回值：
        成功返回数组所有证书组成的Certificates对象，失败返回null
    说明：
        根据证书数组构造Certificates对象
    */
    PKIObject.getCerts=function(certs)
    {
        
        if(certs==null)
         return null;
         
        if (!(typeof certs === 'object' && !isNaN(certs.length)))
        { 
            return null;
        }
        var index = 0;
        var CertificatesArray = new Certificates(); 
        for( index = 0; index < certs.length; ++index)
		{
			  CertificatesArray.push_back(certs[index]);
		
		}
        return CertificatesArray;
    }
    /*声明：
    function generateRandom(length)
    参数：
        length:要产生的随机数长度，数字类型
    返回值：
        返回Hex编码的随机数
    说明：
        产生随机数
    */
    PKIObject.generateRandom=function(randomlength)
    {   
        var pVal = PKIObject._baseObject.GenerateRandom(randomlength);
		return  PKIObject._baseObject.BinaryToHex(pVal, true);
    }
     
    /* 声明：
    function hash(algo,data)
    参数：
        algo:Hash算法,参见2.1.5
        data:要进行Hash的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行hash
    返回值：
        返回Hex编码的Hash值
    说明：
        Hash运算
    */
    PKIObject.hash=function(algo,data)
    {   
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);           
        }
        var  pVal = PKIObject._baseObject.Hash(algo,utf8data);
		return  PKIObject._baseObject.BinaryToHex(pVal, false);
    }
    /*  声明：
    function certEncrypt (cert,data)
    参数：
        cert:Certificate对象
        data:要进行加密的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行加密
    返回值：
        返回证书加密的结果，Byte数组
    说明：
        证书加密数据
    */
    PKIObject.certEncrypt=function(cert,data)
    { 
        if(cert==null)
        {
            return null;
        }
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);
        }    
  
        return PKIObject._baseObject.CertEncrypt(cert._cert,utf8data);
    }
    /* 声明：
    function certDecrypt (cert,data)
    参数：
        cert:Certificate对象
        data:要进行解密的数据，Byte数组 
    返回值：
        返回证书解密的结果，Byte数组
    说明：
        使用证书对应的私钥进行解密数据
    */
    PKIObject.certDecrypt=function(cert,data)
    { 
        if(cert==null)
        {
            return null;
        }
        return PKIObject._baseObject.certDecrypt(cert._cert,data);
    }
    
    /*声明：
    function sign(cert,data)
    参数：
        cert:Certificate对象
        data:要进行签名的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行签名
    返回值：
        返回签名值，Byte数组
    说明：
        使用证书对应的私钥进行签名
    */
     PKIObject.sign=function(cert,data)
    { 
        if(cert==null)
        {
            return null;
        }
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);     
        }    
  
        return PKIObject._baseObject.Sign(cert._cert,utf8data);
    }
    /*3.2.11 verify
    声明：
    function verify(cert,data,signature)
    参数：
        cert:Certificate对象
        data:要进行签名的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行验证
        signature：签名值，Byte数组
    返回值：
        成功返回true,失败返回false
    说明：
        使用证书验证签名
    */
     PKIObject.verify=function(cert,data,signature)
    { 
        if(cert==null)
        {
            return null;
        }
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);
            
        }    
        return PKIObject._baseObject.Verify(cert._cert,utf8data,signature);
    }
    
    /*声明：
    function envelopedDataEncrypt (cert, clearText)
    参数：
        cert:Certificate对象
        clearText:要进行加密的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行加密
    返回值：
        成功返回加密后得到的数字信封，Byte数组
    说明：
        构造数字信封
    */
    
    PKIObject.envelopedDataEncrypt=function(cert,clearText)
    { 
        if(cert==null)
        {
            return null;
        }
        var utf8clearText;
        if(PKIObject._baseObject.IsByteArray(clearText))
        {
            utf8clearText=clearText;
        }
        else
        { 
            utf8clearText=PKIObject._baseObject.UTF8Encode(clearText);       
        }    
  
        return PKIObject._baseObject.EnvelopedDataEncrypt(cert._cert,utf8clearText);
    }
    
    /*声明：
    function envelopedDataDecrypt (cipherText)
    参数：
        cipherText:数字信封数据， Byte数组
    返回值：
        成功返回解密后得到的明文
    说明：
        解开数字信封
    */
    PKIObject.envelopedDataDecrypt=function(cipherText)
    { 
        return  PKIObject._baseObject.EnvelopedDataDecrypt(cipherText);;
    }
    /*声明：
    function envelopedDataGetDecryptCert ()
    参数：
        无
    返回值：
        数字信封解密后成功返回解密Certificate对象
    说明：
        获取解密数字信封的证书。必须在envelopedDataDecrypt成功后使用。
    */
    
    PKIObject.envelopedDataGetDecryptCert=function()
    { 
        var inCert=PKIObject._baseObject.EnvelopedDataGetDecryptCert();
        if(inCert==null)
        {
            return null;
        }
        
        return  new Certificate(inCert); 
    }
    
    /*3.2.15 signedDataSign
    声明：
    function signedDataSign(detached,tbs)
    参数：
        detached:为真表示不带原文，为假表示带原文。布尔类型
        tbs：原文，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行签名
    返回值：
        成功返回SignedData签名得到的结果，Byte数组
    说明：
        SignedData签名。
    */
    PKIObject.signedDataSign=function(cert,detached,tbs)
    { 
        if(cert==null)
        {
            return null;
        }
        var utf8tbs;
        if(PKIObject._baseObject.IsByteArray(tbs))
        {
           utf8tbs=tbs;
        }
        else
        { 
           utf8tbs=PKIObject._baseObject.UTF8Encode(tbs);           
        }           
        return  PKIObject._baseObject.SignedDataSign(cert._cert,detached,utf8tbs); 
    }
    /*
    声明：
    function signedDataVerify(tbs,signature[,cert])
    参数：
        tbs：原文，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行签名
        signature:SignedData值，Byte数组
        cert：签名证书，可选，Certificate对象
    返回值：
        成功返回验证的结果，参见NetcPKIConst.js 2.1.9
    说明：
        验证SignedData签名。
    */
    PKIObject.signedDataVerify=function(tbs,signature,cert)
    { 
 
        var utf8tbs;
        if(PKIObject._baseObject.IsByteArray(tbs))
        {
           utf8tbs=tbs;
        }
        else
        { 
           utf8tbs=PKIObject._baseObject.UTF8Encode(tbs);           
        }   
        if(cert==null)
        {
            return PKIObject._baseObject.SignedDataVerify(utf8tbs,signature); 
        }        
        else
        {
            return  PKIObject._baseObject.SignedDataVerify(utf8tbs,signature,cert._cert); 
        }
    }
    
    /*声明：
    function signedDataGetSignCert()
    参数：
        无
    返回值：
        成功返回SignedData的第一个签名证书，Certifcate对象
    说明：
        验证SignedData签名成功后，获取签名证书。
    */
    PKIObject.signedDataGetSignCert=function()
    { 
        var inCert=PKIObject._baseObject.SignedDataGetSignCert();
        if(inCert==null)
        {
            return null;
        }
        
        return  new Certificate(inCert); 
    }
    /*声明：
    function signedDataAttachTimeStamp ()
    参数：
        无
    返回值：
        成功返回追加时间戳后的SignedData签名，Byte数组
    */

    PKIObject.signedDataAttachTimeStamp=function()
    {  
        return  PKIObject._baseObject.SignedDataAttachTimeStamp();
    }
    /* 声明：
    function signedDataGetTimeStamp ()
    参数：
        无
    返回值：
        成功返回SignedData签名的时间戳时间，Date类型
    说明：
        获取SignedData签名的时间戳时间。
    */
    PKIObject.signedDataGetTimeStamp=function()
    {  
        return  PKIObject._baseObject.SignedDataGetTimeStampTime();
    }
    
    /*声明：
    function timeStampGetToken (data)
    参数：
        data：要进行时间戳的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行Hash
    返回值：
        成功返回时间戳Token，Byte类型
    说明：
        获取时间戳Token
    */
    
    PKIObject.timeStampGetToken=function(data)
    {  
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);           
        }   
        return  PKIObject._baseObject.TimeStampGetToken(utf8data);
    }
    
    /*声明：
    function timeStampGetTime ()
    参数：
        无
    返回值：
        成功返回时间戳的时间，Date类型
    说明：
        获取时间戳时间，必须在timeStampGetToken成功后才能使用
    */   
    PKIObject.timeStampGetTime=function()
    {  
        return  PKIObject._baseObject.TimeStampGetTime();
    }
    
    /*声明：
    function timeStampVerifyToken (data,token)
    参数：
        data：要进行时间戳的数据，可以是Byte数组，也可以是字符串，如果是字符串，则是对其UTF-8编码后才进行Hash
        token:时间戳Token，Byte数组
    返回值：
        成功返回时间戳的时间，Date类型
    说明：
	验证时间戳
    */
    PKIObject.timeStampVerifyToken=function(data,token)
    {  
        var utf8data;
        if(PKIObject._baseObject.IsByteArray(data))
        {
            utf8data=data;
        }
        else
        { 
            utf8data=PKIObject._baseObject.UTF8Encode(data);           
        }   
        return  PKIObject._baseObject.TimeStampVerifyToken(utf8data,token);
    }
    /*声明：
    function getConfig ()
    参数：
        无
    返回值：
        成功返回配置信息的JSON编码，字符串类型
    说明：
        获取配置信息
    */
    PKIObject.getConfig=function(data,token)
    {         
        return  PKIObject._baseObject.GetConfig();
    }
    
    /*声明：
    function setConfig (config)
    参数：
        config:配置信息，字符串类型
    返回值：
        无
    说明：
        设置配置信息
    */
    PKIObject.setConfig=function(config)
    {         
        PKIObject._baseObject.SetConfig(config);
    }
    
    /*声明：
    function getSignAlgo ()
    参数：
        无
    返回值：
        返回签名算法，参见NetcaPKIConst.js 2.1.10
    说明：
        获取配置的签名算法
    */
    PKIObject.getSignAlgo=function(cert)
    {         
        return  PKIObject._baseObject.GetSignAlgo(cert._cert);
    }
    
    /*声明：
    function setSignAlgo (algo)
    参数：
        algo:签名算法，参见2.1.10
    返回值：
        无
    说明：
        设置签名算法
    */
    PKIObject.setSignAlgo=function(certType,algo)
    {         
        PKIObject._baseObject.SetSignAlgo(certType,algo);
    }
    
    /*声明：
    function envelopedDataGetEncAlgo ()
    参数：
        无
    返回值：
        返回数字信封配置的对称加密算法，参见NetcaPKIConst.js 2.1.11
    说明：
        获取数字信封的对称加密算法
    */
    PKIObject.envelopedDataGetEncAlgo=function()
    {         
        return  PKIObject._baseObject.EnvelopedDataGetEncAlgo();
    }
    /*声明：
    function envelopedDataSetEncAlgo (algo)
    参数：
        algo：数字信封的对称加密算法，参见NetcaPKIConst.js 2.1.11
    返回值：
        无
    说明：
        设置数字信封的对称加密算法
    */
    PKIObject.envelopedDataSetEncAlgo=function(algo)
    {         
        PKIObject._baseObject.EnvelopedDataSetEncAlgo(algo);
    }
    /*声明：
    function signedDataGetIncludeCertOption()
    参数：
        无
    返回值：
        返回SignedData配置的包含证书的选项，参见NetcaPKIConst.js 2.1.12
    说明：
        获取SignedData配置的包含证书的选项
    */
    PKIObject.signedDataGetIncludeCertOption=function()
    {         
        return  PKIObject._baseObject.SignedDataGetIncludeCertOption();
    }
    
    /*声明：
    function signedDataSetIncludeCertOption(option)
    参数：
        option：SignedData的包含证书的选项，参见NetcaPKIConst.js 2.1.12
    返回值：
        无
    说明：
        设置SignedData配置的包含证书的选项
    */
    PKIObject.signedDataSetIncludeCertOption=function(option)
    {         
        PKIObject._baseObject.SignedDataSetIncludeCertOption(option);
    }
    /*声明：
    function getSelectCertPolicy()
    参数：
        无
    返回值：
        成功返回选择证书策略的JSON表示，字符串类型
    说明：
        获取选择证书策略
    */
    PKIObject.getSelectCertPolicy=function()
    {         
        return  PKIObject._baseObject.GetSelectCertPolicy();
    }
    
    /*声明：
    function setSelectCertPolicy(policy)
    参数：
        policy:选择证书的策略。字符串类型
    返回值：
        无
    说明：
        设置选择证书策略
    */
    PKIObject.setSelectCertPolicy=function(policy)
    {         
        PKIObject._baseObject.SetSelectCertPolicy(policy);
    }
    /*声明：
    function getFilterCertCondition()
    参数：
        无
    返回值：
        成功返回过滤证书的条件，字符串类型
    说明：
        获取过滤证书的条件
    */
    PKIObject.getFilterCertCondition=function()
    {         
        return  PKIObject._baseObject.GetFilterCertCondition();
    }
    
    /*声明：
    function setFilterCertCondition(condition)
    参数：
        condition：过滤证书的条件
    返回值：
        无
    说明：
        设置过滤证书的条件
    */
    PKIObject.setFilterCertCondition=function(condition)
    {         
        PKIObject._baseObject.SetFilterCertCondition(condition);
    }
    /*声明：
    function getPwdCacheOption()
    参数：
        无
    返回值：
        成功返回配置的密码缓存选项，参见NetcaPKIConst.js 2.1.13
    说明：
        获取配置的密码缓存选项
    */
    PKIObject.getPwdCacheOption=function()
    {         
        return PKIObject._baseObject.GetPwdCacheOption();
    }
    /*声明：
    function setPwdCacheOption(option)
    参数：
        option：配置的密码缓存选项，参见NetcaPKIConst.js 2.1.13
    返回值：
        无
    说明：
        设置配置的密码缓存选项
    */
    PKIObject.setPwdCacheOption=function(option)
    {         
        PKIObject._baseObject.SetPwdCacheOption(option);
    }
    
   /* 声明：
    function resetConfig()
    参数：
        无
    返回值：
        无
    说明：
        重置配置信息
    */
    PKIObject.resetConfig=function()
    {         
        PKIObject._baseObject.Reset();
    }
    
    /*声明：
    function getVersion()
    参数：
        无
    返回值：
        返回版本信息，字符串类型
    说明：
        获取版本信息
    */
    PKIObject.getVersion=function()
    {         
        return PKIObject._baseObject.GetVersionInfo();
    }
    /*
    声明：
    function hexEncode(data)
    参数：
        data：要进行编码的数据，Byte数组
    返回值：
        返回Hex编码的字符串，字符串类型
    说明：
        Hex编码
    */
    PKIObject.hexEncode=function(data)
    {       
        //这里默认都是小写
        return PKIObject._baseObject.BinaryToHex(data, false);       
    }
    /*声明：
    function hexDecode(hex)
    参数：
        hex：要进行Hex解码的字符串，字符串类型
    返回值：
        返回Hex解码后的数据，Byte数组
    说明：
        Hex解码
    */
    PKIObject.hexDecode=function(hex)
    {       
        return PKIObject._baseObject.HexToBinary(hex);       
    }
    
    /*声明：
    function base64Encode(data[,multiLine])
    参数：
        data：要进行编码的数据，Byte数组
        multiLine:为真表示多行编码，为假表示不分行。布尔类型，可选参数，默认为false
    返回值：
        返回Base64编码的字符串，字符串类型
    说明：
        Base64编码
    */
    PKIObject.base64Encode=function(data,multiLine)
    {   
        var   NETCA_PKI_BASE64_NO_NL	=1;
        var   NETCA_PKI_BASE64_STRICT	=2;
        var bmultiLine=NETCA_PKI_BASE64_NO_NL;
        if(multiLine!=null&&multiLine)
        {
            bmultiLine=NETCA_PKI_BASE64_STRICT;
        }
        return PKIObject._baseObject.Base64Encode(data,bmultiLine);       
    }
    /* 声明：
    function base64Decode(b64Str[,strict])
    参数：
        b64Str：Base64编码的字符串，字符串类型
        strict:为真表示仅仅处理不分行的Base64编码，为假表示分行和不分行都可以解码。布尔类型，可选参数，默认为false
    返回值：
        返回Base64解码后的数据，Byte数组
    说明：
        Base64解码
    */
    
    PKIObject.base64Decode=function(data,strict)
    {     
        
       var   NETCA_PKI_BASE64_NO_NL		=1;
       var   NETCA_PKI_BASE64_STRICT	=2;
       var   bStrict=NETCA_PKI_BASE64_NO_NL;

        if(strict!=null&&strict)
        {
            bStrict=NETCA_PKI_BASE64_STRICT;
        }
        return PKIObject._baseObject.Base64Decode(data,bStrict);       
    }
    /*声明：
    function stringEncode(str[,charset])
    参数：
        str：要进行编码的字符串，字符串类型
        charset:字符集，字符串类型，可选参数，默认为utf-8。
    返回值：
        返回字符串的编码，Byte数组
    说明：
        字符串编码
    */
    PKIObject.stringEncode=function(str,charset)
    {
        var NETCAPKI_CP_UTF8	=	65001;     
        var incharset=NETCAPKI_CP_UTF8;
        if(charset!=null)
        {
            incharset=charset;
        }
        return PKIObject._baseObject.Encode(str,incharset);       
    }
    
    /*声明：
    function newString (data[,charset])
    参数：
        data：字符串的编码，Byte数组
        charset:字符集，字符串类型，可选参数，默认为utf-8。
    返回值：
        返回字符串的编码，Byte类型
    说明：
        根据字符串编码构造字符串
    */
    PKIObject.newString=function(data,charset)
    {
        var NETCAPKI_CP_UTF8	=	65001;     
        var incharset=NETCAPKI_CP_UTF8;
        if(charset!=null)
        {
            incharset=charset;
        }
        return PKIObject._baseObject.Decode(data,incharset);       
    }
    /*声明：
    function getLastError()
    参数：
        无
    返回值：
        返回错误号，数字类型
    说明：
        获取最后出现的错误的错误号
    */
     PKIObject.getLastError=function()
    {
   
        return PKIObject._baseObject.GetLastError();       
    }
    /*声明：
    function getLastErrorMsg()
    参数：
        无
    返回值：
        返回错误信息，字符串类型
    说明：
        获取最后出现的错误的错误信息
    */
    PKIObject.getLastErrorMsg=function()
    {
   
        return PKIObject._baseObject.GetLastErrorMsg();       
    }
    /*声明：
    function isKeyInserted()
    参数：
        无
    返回值：
        有USB Key插入返回true,没有返回false。布尔类型
    说明：
        判断当前是否有USB Key插入
    */
    PKIObject.isKeyInserted=function()
    {
        return PKIObject._baseObject.IsKeyInserted();       
    }
    /*声明：
    function isValidTime(time)
    参数：
        无
    返回值：
        时间类型返回true,没有返回false。布尔类型
    说明：
        判断类型是否为时间类型
    */
     PKIObject.isValidTime=function(time)
     {
         return PKIObject._baseObject.IsValidTime(time);    
     }
    /*声明：
    function verifyCert(cert,flag)
    参数：
    cert：Certificate对象
    flag:验证证书的标志，参见2.1.15
    返回值：
        返回证书的状态，参见2.1.14
    说明：
        验证证书，获取证书的状态
    */
    PKIObject.verifyCert=function(cert,flag)
    {
        if(cert==null)
        {
             return null; 
        }
        var certPathObject=PKIObject._baseObject.CreateCertPathObject();
        return certPathObject.Verify(cert._cert,flag);       
    }
  
 
    initializeObject(PKIObject);
    
    return PKIObject;
    
}());


